package cn.edu.swu.miniwebsvr.core;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public class HttpParser {

    public static Parameter parse(InputStream inputStream) throws IOException {
        Parameter parameter = new Parameter();

        // TODO: [222024321072035/万能]

        BufferedReader reader = new BufferedReader(
                new InputStreamReader(inputStream, StandardCharsets.UTF_8)
        );

        // 1. 解析请求行
        String requestLine = reader.readLine();
        if (requestLine == null || requestLine.isEmpty()) {
            throw new IOException("无效的请求行");
        }
        parseRequestLine(requestLine, parameter);

        // 2. 解析请求头
        String headerLine;
        while ((headerLine = reader.readLine()) != null && !headerLine.isEmpty()) {
            parseHeaderLine(headerLine, parameter);
        }

        // 3. 解析请求体（POST方法）
        if ("POST".equalsIgnoreCase(parameter.getMethod())) {
            parseBody(reader, parameter);
        }

        return parameter;
    }

    // TODO: [222024321072035/万能] 可以添加辅助方法来简化字符串解析和 URL 解码
    private static void parseRequestLine(String requestLine, Parameter parameter) throws IOException {
        String[] parts = requestLine.split("\\s+");
        if (parts.length < 3) {
            throw new IOException("无效的请求行格式: " + requestLine);
        }

        // 设置请求方法
        parameter.setMethod(parts[0]);

        // 解析URL和参数
        String url = parts[1];
        int queryIndex = url.indexOf('?');
        if (queryIndex != -1) {
            // 提取URL路径
            parameter.setUrl(url.substring(0, queryIndex));
            // 解析URL参数
            String query = url.substring(queryIndex + 1);
            parseParams(query, parameter::addUrlParam);
        } else {
            parameter.setUrl(url);
        }
    }

    // 解析请求头
    private static void parseHeaderLine(String headerLine, Parameter parameter) {
        int colonIndex = headerLine.indexOf(':');
        if (colonIndex != -1) {
            String key = headerLine.substring(0, colonIndex).trim();
            String value = headerLine.substring(colonIndex + 1).trim();
            parameter.addHeader(key, value);
        }
    }

    // 解析请求体（POST参数）
    private static void parseBody(BufferedReader reader, Parameter parameter) throws IOException {
        // 获取Content-Length
        String contentLengthStr = parameter.getHeaders().get("Content-Length");
        if (contentLengthStr == null) {
            return; // 无请求体
        }

        int contentLength;
        try {
            contentLength = Integer.parseInt(contentLengthStr);
        } catch (NumberFormatException e) {
            throw new IOException("无效的Content-Length: " + contentLengthStr);
        }

        // 读取请求体内容
        char[] bodyChars = new char[contentLength];
        int bytesRead = reader.read(bodyChars, 0, contentLength);
        if (bytesRead != contentLength) {
            throw new IOException("读取请求体不完整");
        }
        String body = new String(bodyChars, 0, bytesRead);

        // 解析参数（仅处理application/x-www-form-urlencoded类型）
        String contentType = parameter.getHeaders().get("Content-Type");
        if (contentType != null && contentType.contains("application/x-www-form-urlencoded")) {
            parseParams(body, parameter::addBodyParam);
        }
    }

    // 通用参数解析（支持URL和Body参数）
    private static void parseParams(String paramStr, ParamConsumer consumer) throws IOException {
        String[] params = paramStr.split("&");
        for (String param : params) {
            if (param.isEmpty()) continue;

            String[] keyValue = param.split("=", 2);
            String key = URLDecoder.decode(keyValue[0], StandardCharsets.UTF_8.name());
            String value = keyValue.length > 1 ?
                    URLDecoder.decode(keyValue[1], StandardCharsets.UTF_8.name()) :
                    "";
            consumer.accept(key, value);
        }
    }

    // 函数式接口：用于处理解析后的参数
    @FunctionalInterface
    private interface ParamConsumer {
        void accept(String key, String value);
    }
}
